home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gnu / adainc / a-strbou.ads < prev    next >
Text File  |  1996-01-30  |  13KB  |  446 lines
  1. ------------------------------------------------------------------------------
  2. --                                                                          --
  3. --                         GNAT RUNTIME COMPONENTS                          --
  4. --                                                                          --
  5. --                  A D A . S T R I N G S . B O U N D E D                   --
  6. --                                                                          --
  7. --                                 S p e c                                  --
  8. --                                                                          --
  9. --                            $Revision: 1.8 $                              --
  10. --                                                                          --
  11. -- This specification is adapted from the Ada Reference Manual for use with --
  12. -- GNAT.  In accordance with the copyright of that document, you can freely --
  13. -- copy and modify this specification,  provided that if you redistribute a --
  14. -- modified version,  any changes that you have made are clearly indicated. --
  15. --                                                                          --
  16. ------------------------------------------------------------------------------
  17.  
  18.  
  19. with Ada.Strings.Maps;
  20.  
  21. package Ada.Strings.Bounded is
  22. pragma Preelaborate (Bounded);
  23.  
  24.    generic
  25.       Max : Positive;
  26.       --  Maximum length of a Bounded_String
  27.  
  28.    package Generic_Bounded_Length is
  29.  
  30.       Max_Length : constant Positive := Max;
  31.  
  32.       type Bounded_String is private;
  33.  
  34.       Null_Bounded_String : constant Bounded_String;
  35.  
  36.       subtype Length_Range is Natural range 0 .. Max_Length;
  37.  
  38.       function Length (Source : in Bounded_String) return Length_Range;
  39.  
  40.       --------------------------------------------------------
  41.       -- Conversion, Concatenation, and Selection Functions --
  42.       --------------------------------------------------------
  43.  
  44.       function To_Bounded_String
  45.         (Source : in String;
  46.          Drop   : in Truncation := Error)
  47.          return   Bounded_String;
  48.  
  49.       function To_String (Source : in Bounded_String) return String;
  50.  
  51.       function Append
  52.         (Left, Right : in Bounded_String;
  53.          Drop        : in Truncation  := Error)
  54.          return        Bounded_String;
  55.  
  56.       function Append
  57.         (Left  : in Bounded_String;
  58.          Right : in String;
  59.          Drop  : in Truncation := Error)
  60.          return  Bounded_String;
  61.  
  62.       function Append
  63.         (Left  : in String;
  64.          Right : in Bounded_String;
  65.          Drop  : in Truncation := Error)
  66.          return  Bounded_String;
  67.  
  68.       function Append
  69.         (Left  : in Bounded_String;
  70.          Right : in Character;
  71.          Drop  : in Truncation := Error)
  72.          return  Bounded_String;
  73.  
  74.       function Append
  75.         (Left  : in Character;
  76.          Right : in Bounded_String;
  77.          Drop  : in Truncation := Error)
  78.          return  Bounded_String;
  79.  
  80.       procedure Append
  81.         (Source   : in out Bounded_String;
  82.          New_Item : in Bounded_String;
  83.          Drop     : in Truncation  := Error);
  84.  
  85.       procedure Append
  86.         (Source   : in out Bounded_String;
  87.          New_Item : in String;
  88.          Drop     : in Truncation  := Error);
  89.  
  90.       procedure Append
  91.         (Source   : in out Bounded_String;
  92.          New_Item : in Character;
  93.          Drop     : in Truncation  := Error);
  94.  
  95.       function "&"
  96.         (Left, Right : in Bounded_String)
  97.          return        Bounded_String;
  98.  
  99.       function "&"
  100.         (Left  : in Bounded_String;
  101.          Right : in String)
  102.          return  Bounded_String;
  103.  
  104.       function "&"
  105.         (Left  : in String;
  106.          Right : in Bounded_String)
  107.          return  Bounded_String;
  108.  
  109.       function "&"
  110.         (Left  : in Bounded_String;
  111.          Right : in Character)
  112.          return  Bounded_String;
  113.  
  114.       function "&"
  115.         (Left  : in Character;
  116.          Right : in Bounded_String)
  117.          return  Bounded_String;
  118.  
  119.       function Element
  120.         (Source : in Bounded_String;
  121.          Index  : in Positive)
  122.          return   Character;
  123.  
  124.       procedure Replace_Element
  125.         (Source : in out Bounded_String;
  126.          Index  : in Positive;
  127.          By     : in Character);
  128.  
  129.       function Slice
  130.         (Source : in Bounded_String;
  131.          Low    : in Positive;
  132.          High   : in Natural)
  133.          return   String;
  134.  
  135.       function "="  (Left, Right : in Bounded_String) return Boolean;
  136.  
  137.       function "="
  138.         (Left  : in Bounded_String;
  139.          Right : in String)
  140.          return  Boolean;
  141.  
  142.       function "="
  143.         (Left  : in String;
  144.          Right : in Bounded_String)
  145.          return  Boolean;
  146.  
  147.       function "<"  (Left, Right : in Bounded_String) return Boolean;
  148.  
  149.       function "<"
  150.         (Left  : in Bounded_String;
  151.          Right : in String)
  152.          return  Boolean;
  153.  
  154.       function "<"
  155.         (Left  : in String;
  156.          Right : in Bounded_String)
  157.          return  Boolean;
  158.  
  159.       function "<=" (Left, Right : in Bounded_String) return Boolean;
  160.  
  161.       function "<="
  162.         (Left  : in Bounded_String;
  163.          Right : in String)
  164.          return  Boolean;
  165.  
  166.       function "<="
  167.         (Left  : in String;
  168.          Right : in Bounded_String)
  169.          return  Boolean;
  170.  
  171.       function ">"  (Left, Right : in Bounded_String) return Boolean;
  172.  
  173.       function ">"
  174.         (Left  : in Bounded_String;
  175.          Right : in String)
  176.          return  Boolean;
  177.  
  178.       function ">"
  179.         (Left  : in String;
  180.          Right : in Bounded_String)
  181.          return  Boolean;
  182.  
  183.       function ">=" (Left, Right : in Bounded_String) return Boolean;
  184.  
  185.       function ">="
  186.         (Left  : in Bounded_String;
  187.          Right : in String)
  188.          return  Boolean;
  189.  
  190.       function ">="
  191.         (Left  : in String;
  192.          Right : in Bounded_String)
  193.          return  Boolean;
  194.  
  195.       ----------------------
  196.       -- Search Functions --
  197.       ----------------------
  198.  
  199.       function Index
  200.         (Source  : in Bounded_String;
  201.          Pattern : in String;
  202.          Going   : in Direction := Forward;
  203.          Mapping : in Maps.Character_Mapping := Maps.Identity)
  204.          return    Natural;
  205.  
  206.       function Index
  207.         (Source  : in Bounded_String;
  208.          Pattern : in String;
  209.          Going   : in Direction := Forward;
  210.          Mapping : in Maps.Character_Mapping_Function)
  211.          return    Natural;
  212.  
  213.       function Index
  214.         (Source : in Bounded_String;
  215.          Set    : in Maps.Character_Set;
  216.          Test   : in Membership := Inside;
  217.          Going  : in Direction  := Forward)
  218.          return   Natural;
  219.  
  220.       function Index_Non_Blank
  221.         (Source : in Bounded_String;
  222.          Going  : in Direction := Forward)
  223.          return   Natural;
  224.  
  225.       function Count
  226.         (Source  : in Bounded_String;
  227.          Pattern : in String;
  228.          Mapping : in Maps.Character_Mapping := Maps.Identity)
  229.          return    Natural;
  230.  
  231.       function Count
  232.         (Source  : in Bounded_String;
  233.          Pattern : in String;
  234.          Mapping : in Maps.Character_Mapping_Function)
  235.          return    Natural;
  236.  
  237.       function Count
  238.         (Source : in Bounded_String;
  239.          Set    : in Maps.Character_Set)
  240.          return   Natural;
  241.  
  242.       procedure Find_Token
  243.         (Source : in Bounded_String;
  244.          Set    : in Maps.Character_Set;
  245.          Test   : in Membership;
  246.          First  : out Positive;
  247.          Last   : out Natural);
  248.  
  249.       ------------------------------------
  250.       -- String Translation Subprograms --
  251.       ------------------------------------
  252.  
  253.       function Translate
  254.         (Source   : in Bounded_String;
  255.          Mapping  : in Maps.Character_Mapping)
  256.          return     Bounded_String;
  257.  
  258.       procedure Translate
  259.         (Source   : in out Bounded_String;
  260.          Mapping  : in Maps.Character_Mapping);
  261.  
  262.       function Translate
  263.         (Source  : in Bounded_String;
  264.          Mapping : in Maps.Character_Mapping_Function)
  265.          return    Bounded_String;
  266.  
  267.       procedure Translate
  268.         (Source  : in out Bounded_String;
  269.          Mapping : in Maps.Character_Mapping_Function);
  270.  
  271.       ---------------------------------------
  272.       -- String Transformation Subprograms --
  273.       ---------------------------------------
  274.  
  275.       function Replace_Slice
  276.         (Source   : in Bounded_String;
  277.          Low      : in Positive;
  278.          High     : in Natural;
  279.          By       : in String;
  280.          Drop     : in Truncation := Error)
  281.          return     Bounded_String;
  282.  
  283.       procedure Replace_Slice
  284.         (Source   : in out Bounded_String;
  285.          Low      : in Positive;
  286.          High     : in Natural;
  287.          By       : in String;
  288.          Drop     : in Truncation := Error);
  289.  
  290.       function Insert
  291.         (Source   : in Bounded_String;
  292.          Before   : in Positive;
  293.          New_Item : in String;
  294.          Drop     : in Truncation := Error)
  295.          return     Bounded_String;
  296.  
  297.       procedure Insert
  298.         (Source   : in out Bounded_String;
  299.          Before   : in Positive;
  300.          New_Item : in String;
  301.          Drop     : in Truncation := Error);
  302.  
  303.       function Overwrite
  304.         (Source    : in Bounded_String;
  305.          Position  : in Positive;
  306.          New_Item  : in String;
  307.          Drop      : in Truncation := Error)
  308.          return      Bounded_String;
  309.  
  310.       procedure Overwrite
  311.         (Source    : in out Bounded_String;
  312.          Position  : in Positive;
  313.          New_Item  : in String;
  314.          Drop      : in Truncation := Error);
  315.  
  316.       function Delete
  317.         (Source  : in Bounded_String;
  318.          From    : in Positive;
  319.          Through : in Natural)
  320.          return    Bounded_String;
  321.  
  322.       procedure Delete
  323.         (Source  : in out Bounded_String;
  324.          From    : in Positive;
  325.          Through : in Natural);
  326.  
  327.       ---------------------------------
  328.       -- String Selector Subprograms --
  329.       ---------------------------------
  330.  
  331.       function Trim
  332.         (Source : in Bounded_String;
  333.          Side   : in Trim_End)
  334.          return   Bounded_String;
  335.  
  336.       procedure Trim
  337.         (Source : in out Bounded_String;
  338.          Side   : in Trim_End);
  339.  
  340.       function Trim
  341.         (Source  : in Bounded_String;
  342.           Left   : in Maps.Character_Set;
  343.           Right  : in Maps.Character_Set)
  344.           return   Bounded_String;
  345.  
  346.       procedure Trim
  347.         (Source : in out Bounded_String;
  348.          Left   : in Maps.Character_Set;
  349.          Right  : in Maps.Character_Set);
  350.  
  351.       function Head
  352.         (Source : in Bounded_String;
  353.          Count  : in Natural;
  354.          Pad    : in Character := Space;
  355.          Drop   : in Truncation := Error)
  356.          return   Bounded_String;
  357.  
  358.       procedure Head
  359.         (Source : in out Bounded_String;
  360.          Count  : in Natural;
  361.          Pad    : in Character  := Space;
  362.          Drop   : in Truncation := Error);
  363.  
  364.       function Tail
  365.         (Source : in Bounded_String;
  366.          Count  : in Natural;
  367.          Pad    : in Character  := Space;
  368.          Drop   : in Truncation := Error)
  369.          return Bounded_String;
  370.  
  371.       procedure Tail
  372.         (Source : in out Bounded_String;
  373.          Count  : in Natural;
  374.          Pad    : in Character  := Space;
  375.          Drop   : in Truncation := Error);
  376.  
  377.       ------------------------------------
  378.       -- String Constructor Subprograms --
  379.       ------------------------------------
  380.  
  381.       function "*"
  382.         (Left  : in Natural;
  383.          Right : in Character)
  384.          return  Bounded_String;
  385.  
  386.       function "*"
  387.         (Left  : in Natural;
  388.          Right : in String)
  389.          return  Bounded_String;
  390.  
  391.       function "*"
  392.         (Left  : in Natural;
  393.          Right : in Bounded_String)
  394.          return  Bounded_String;
  395.  
  396.       function Replicate
  397.         (Count : in Natural;
  398.          Item  : in Character;
  399.          Drop  : in Truncation := Error)
  400.          return  Bounded_String;
  401.  
  402.       function Replicate
  403.         (Count : in Natural;
  404.          Item  : in String;
  405.          Drop  : in Truncation := Error)
  406.          return  Bounded_String;
  407.  
  408.       function Replicate
  409.         (Count : in Natural;
  410.          Item  : in Bounded_String;
  411.          Drop  : in Truncation := Error)
  412.          return  Bounded_String;
  413.  
  414.    private
  415.  
  416.       type Bounded_String is record
  417.          Length : Length_Range;
  418.          Data   : String (1 .. Max_Length);
  419.       end record;
  420.  
  421.       Null_Bounded_String : constant Bounded_String :=
  422.                (Length => 0, Data => (1 .. Max_Length => Ascii.NUL));
  423.  
  424.       --  Pragma Inline declarations (GNAT specific additions)
  425.  
  426.       pragma Inline ("=");
  427.       pragma Inline ("<");
  428.       pragma Inline ("<=");
  429.       pragma Inline (">");
  430.       pragma Inline (">=");
  431.       pragma Inline ("&");
  432.       pragma Inline (Count);
  433.       pragma Inline (Element);
  434.       pragma Inline (Find_Token);
  435.       pragma Inline (Index);
  436.       pragma Inline (Index_Non_Blank);
  437.       pragma Inline (Length);
  438.       pragma Inline (Replace_Element);
  439.       pragma Inline (Slice);
  440.       pragma Inline (To_Bounded_String);
  441.       pragma Inline (To_String);
  442.  
  443.    end Generic_Bounded_Length;
  444.  
  445. end Ada.Strings.Bounded;
  446.